package com.example.apitesttool.agent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 智能体路由器
 * 根据智能体状态和节点执行结果，决定下一个要执行的节点
 */
@Component
public class AgentRouter {
    
    private static final Logger logger = LoggerFactory.getLogger(AgentRouter.class);
    
    /**
     * 根据当前状态决定下一个节点
     * @param state 智能体状态
     * @param lastResult 上一个节点的执行结果
     * @return 下一个节点的名称
     */
    public String routeNext(AgentState state, AgentNodeResult lastResult) {
        logger.debug("路由决策 - 当前意图: {}, 任务状态: {}, 步骤: {}", 
                    state.getCurrentIntent(), state.getTaskStatus(), state.getStepCount());
        
        // 如果上一个节点明确指定了下一个节点
        if (lastResult != null && lastResult.getNextNodeName() != null) {
            logger.debug("使用节点指定的下一步: {}", lastResult.getNextNodeName());
            return lastResult.getNextNodeName();
        }
        
        // 如果有错误，转到错误处理节点
        if (state.hasError()) {
            logger.debug("检测到错误，转到错误处理节点");
            return "ErrorHandlingNode";
        }
        
        // 如果任务已完成
        if ("COMPLETED".equals(state.getTaskStatus())) {
            logger.debug("任务已完成，转到响应生成节点");
            return "ResponseGenerationNode";
        }
        
        // 根据当前意图和状态进行路由
        String currentIntent = state.getCurrentIntent();
        
        // 如果还没有识别意图，先进行意图识别
        if (currentIntent == null || currentIntent.isEmpty()) {
            logger.debug("未识别意图，转到意图识别节点");
            return "IntentRecognitionNode";
        }
        
        // 根据意图进行路由
        switch (currentIntent) {
            case "QUERY_API":
            case "SEARCH_INTERFACE":
                return routeForApiQuery(state);
                
            case "EXECUTE_TEST":
            case "SEND_REQUEST":
                return routeForTestExecution(state);
                
            case "SET_PARAMETER":
            case "CONFIGURE":
                return routeForParameterSetting(state);
                
            case "GET_SERVER_INFO":
            case "QUERY_INFO":
                return routeForInfoQuery(state);
                
            default:
                logger.debug("未知意图: {}, 转到意图识别节点重新分析", currentIntent);
                return "IntentRecognitionNode";
        }
    }
    
    /**
     * API 查询相关的路由逻辑
     */
    private String routeForApiQuery(AgentState state) {
        // 如果还没有搜索 API，先搜索
        if (state.getIdentifiedApiInfo() == null && state.getCandidateApis().isEmpty()) {
            logger.debug("需要搜索 API，转到 API 搜索节点");
            return "ApiSearchNode";
        }
        
        // 如果有候选 API 但没有确定的 API，需要用户选择或进一步搜索
        if (state.getIdentifiedApiInfo() == null && !state.getCandidateApis().isEmpty()) {
            logger.debug("有候选 API 但未确定，转到响应生成节点让用户选择");
            return "ResponseGenerationNode";
        }
        
        // 如果已经有确定的 API，生成响应
        if (state.getIdentifiedApiInfo() != null) {
            logger.debug("已找到 API 信息，转到响应生成节点");
            return "ResponseGenerationNode";
        }
        
        return "ApiSearchNode";
    }
    
    /**
     * 测试执行相关的路由逻辑
     */
    private String routeForTestExecution(AgentState state) {
        // 如果没有确定的 API，先搜索
        if (state.getIdentifiedApiInfo() == null) {
            logger.debug("执行测试但未找到 API，转到 API 搜索节点");
            return "ApiSearchNode";
        }
        
        // 检查是否有缺失的必需参数
        if (!state.getMissingParameters().isEmpty()) {
            logger.debug("有缺失参数，转到参数收集节点");
            return "ParameterCollectionNode";
        }
        
        // 参数齐全，执行工具
        logger.debug("参数齐全，转到工具执行节点");
        return "ToolExecutionNode";
    }
    
    /**
     * 参数设置相关的路由逻辑
     */
    private String routeForParameterSetting(AgentState state) {
        logger.debug("参数设置意图，转到参数收集节点");
        return "ParameterCollectionNode";
    }
    
    /**
     * 信息查询相关的路由逻辑
     */
    private String routeForInfoQuery(AgentState state) {
        logger.debug("信息查询意图，转到 API 搜索节点");
        return "ApiSearchNode";
    }
    
    /**
     * 获取初始节点
     * @return 初始节点名称
     */
    public String getInitialNode() {
        return "IntentRecognitionNode";
    }
    
    /**
     * 检查是否应该继续执行
     * @param state 智能体状态
     * @param result 最后的执行结果
     * @return 是否应该继续
     */
    public boolean shouldContinue(AgentState state, AgentNodeResult result) {
        // 检查步骤数限制，防止无限循环
        if (state.getStepCount() > 20) {
            logger.warn("步骤数超过限制，停止执行");
            return false;
        }
        
        // 检查状态标志
        if (!state.isShouldContinue()) {
            logger.debug("状态标志指示停止执行");
            return false;
        }
        
        // 检查结果标志
        if (result != null && !result.isShouldContinue()) {
            logger.debug("节点结果指示停止执行");
            return false;
        }
        
        // 检查任务状态
        if ("COMPLETED".equals(state.getTaskStatus()) && state.getLastToolResult() != null) {
            logger.debug("任务已完成且有结果，停止执行");
            return false;
        }
        
        return true;
    }
}

